Aminet 1/Aminet - June 1993 [Walnut Creek].iso/usenet/sources/volume90/aplictns/dkbtrace/part09

Internet Message Format | 1990-09-03 | 66.6 KB

Path: abcfd20.larc.nasa.gov!amiga-request
From: [e-mail] (Amiga Sources/Binaries Moderator)
Subject: v90i257: DKBTrace 2.01 - DKBtrace Ray-Tracer, Part09/10
Reply-To: David Schanen <[e-mail]>
Newsgroups: comp.sources.amiga
Message-ID: <comp.sources.amiga:[e-mail]>
References: <comp.sources.amiga:[e-mail]>
Date: 03 Sep 90 23:22:40 GMT
Approved: [e-mail] (Tad Guy)
X-Mail-Submissions-To: [e-mail]
X-Post-Discussions-To: comp.sys.amiga

Submitted-by: David Schanen <[e-mail]>
Posting-number: Volume 90, Issue 257
Archive-name: applications/dkbtrace-2.01/part09

#!/bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#        "End of archive 9 (of 10)."
# Contents:  src/parse.c
# Wrapped by tadguy@abcfd20 on Mon Sep  3 19:21:22 1990
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'src/parse.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'src/parse.c'\"
else
echo shar: Extracting \"'src/parse.c'\" \(63678 characters\)
sed "s/^X//" >'src/parse.c' <<'END_OF_FILE'
X/*****************************************************************************
X*
X*                                    parse.c
X*
X*   from DKBTrace (c) 1990  David Buck
X*
X*  This module implements a parser for the scene description files.
X*
X* This software is freely distributable. The source and/or object code may be
X* copied or uploaded to communications services so long as this notice remains
X* at the top of each file.  If any changes are made to the program, you must
X* clearly indicate in the documentation and in the programs startup message
X* who it was who made the changes. The documentation should also describe what
X* those changes were. This software may not be included in whole or in
X* part into any commercial package without the express written consent of the
X* author.  It may, however, be included in other public domain or freely
X* distributed software so long as the proper credit for the software is given.
X*
X* This software is provided as is without any guarantees or warranty. Although
X* the author has attempted to find and correct any bugs in the software, he
X* is not responsible for any damage caused by the use of the software.  The
X* author is under no obligation to provide service, corrections, or upgrades
X* to this package.
X*
X* Despite all the legal stuff above, if you do find bugs, I would like to hear
X* about them.  Also, if you have any comments or questions, you may contact me
X* at the following address:
X*
X*     David Buck
X*     22C Sonnet Cres.
X*     Nepean Ontario
X*     Canada, K2H 8W7
X*
X*  I can also be reached on the following bulleton boards:
X*
X*     ATX              [phone]
X*     OMX              [phone]
X*     Mystic           [phone] or [phone]
X*
X*  Fidonet:   1:163/109.9
X*  Internet:  [e-mail]
X*
X*  IBM Port by Aaron A. Collins. Aaron may be reached on the following BBS'es:
X*
X*     Lattice BBS                      [phone]
X*     The Information Exchange BBS     [phone]
X*     Stillwaters BBS                  [phone]
X*
X*****************************************************************************/
X
X#include "frame.h"
X#include "vector.h"
X#include "dkbproto.h"
X
X/* This file implements a simple recursive-descent parser for reading the
Xinput file.  */
X
Xextern FILE *Token_File;
XFRAME *Parsing_Frame_Ptr;
Xchar Current_File_Name[20];
X
Xextern METHODS Composite_Methods;
Xextern METHODS Basic_Object_Methods;
Xextern METHODS Sphere_Methods;
Xextern METHODS Quadric_Methods;
Xextern METHODS Viewpoint_Methods;
Xextern METHODS Plane_Methods;
Xextern METHODS Triangle_Methods;
Xextern METHODS Smooth_Triangle_Methods;
Xextern METHODS CSG_Union_Methods;
Xextern METHODS CSG_Intersection_Methods;
X
Xextern struct Reserved_Word_Struct Reserved_Words [];
Xextern DBL Antialias_Threshold;
X
Xstruct Token_Struct Token;
X
X#define MAX_CONSTANTS 100
Xstruct Constant_Struct Constants[MAX_CONSTANTS];
Xint Number_Of_Constants;
XTEXTURE *Default_Texture;
Xint Degenerate_Triangles;
X
X/* Here we create out own little language for doing the parsing.  It
Xmakes the code easier to read. */
X
X#define EXPECT { int Exit_Flag; Exit_Flag = FALSE; \
X while (!Exit_Flag) {Get_Token();  switch (Token.Token_Id) {
X#define CASE(x) case x:
X#define CASE2(x, y) case x: case y:
X#define CASE3(x, y, z) case x: case y: case z:
X#define CASE4(w, x, y, z) case w: case x: case y: case z:
X#define CASE5(v, w, x, y, z) case v: case w: case x: case y: case z:
X#define END_CASE break;
X#define EXIT Exit_Flag = TRUE;
X#define OTHERWISE default:
X#define END_EXPECT } } }
X#define GET(x) Get_Token(); if (Token.Token_Id != x) Parse_Error (x)
X#define UNGET Unget_Token();
X
X/* Parse the file into the given frame. */
Xvoid Parse (File, Frame_Ptr)
X  FILE *File;
X  FRAME *Frame_Ptr;
X  {
X  Token_File = File;
X  Parsing_Frame_Ptr = Frame_Ptr;
X
X  Degenerate_Triangles = FALSE;
X  Token_Init ();
X  Frame_Init ();
X  Parse_Frame ();
X  if (Degenerate_Triangles) {
X     printf ("Cannot continue due to degenerate triangles.\n");
X     exit(1);
X     }
X  }
X
Xvoid Token_Init ()
X  {
X  Token.Unget_Token = FALSE;
X  Token.End_Of_File = FALSE;
X  Number_Of_Constants = 0;
X  }
X
X/* Read a token from the input file and store it in the Token variable.
XIf the token is an INCLUDE token, then set the include file name and
Xread another token. */
X
Xint Get_Token ()
X  {
X  char *str_ptr;
X  int Token_Id;
X
X  if (Token.Unget_Token)
X    {
X    Token.Unget_Token = FALSE;
X    return (TRUE);
X    }
X
X  if (Token.End_Of_File)
X    {
X    return (FALSE);
X    }
X
X  if (fscanf (Token_File, "%d %d", &Token_Id, &Token.Token_Line_No)
X       != 2)
X    {
X    Token.End_Of_File = TRUE;
X    Token.Token_Id    = END_OF_FILE_TOKEN;
X    return (TRUE);
X    }
X
X  Token.Token_Id = Token_Id;
X
X  getc(Token_File);
X  if (fgets (Token.Token_String, FILE_NAME_LENGTH, Token_File) == NULL)
X    {
X    Token.End_Of_File = TRUE;
X    Token.Token_Id    = END_OF_FILE_TOKEN;
X    return (TRUE);
X    }
X
X  if ((str_ptr = strchr(Token.Token_String, '\n')) != NULL)
X     *str_ptr = '\0';
X
X  if (Token.Token_Id == FLOAT_TOKEN)
X    if (sscanf (Token.Token_String, DBL_FORMAT_STRING, &(Token.Token_Float)) != 1)
X      {
X      printf ("Premature end of file in token file\n");
X      printf ("Could not read float: %s\n", Token.Token_String);
X      Token.End_Of_File = TRUE;
X      Token.Token_Id    = END_OF_FILE_TOKEN;
X      return (TRUE);
X      }
X
X  if (Token.Token_Id == INCLUDE_TOKEN) {
X     strcpy (Current_File_Name, Token.Token_String);
X     return (Get_Token());
X     }
X
X  if (Token.Token_Id > LAST_TOKEN)
X    {
X    Token.Identifier_Number = (int) Token.Token_Id - (int) LAST_TOKEN;
X    Token.Token_Id = IDENTIFIER_TOKEN;
X    }
X
X  return (TRUE);
X  }
X
X
X/* Mark that the token has been put back into the input stream.  The next
Xcall to Get_Token will return the last-read token instead of reading a
Xnew one from the file. */
X
Xvoid Unget_Token ()
X  {
X  Token.Unget_Token = TRUE;
X  }
X
X/* Set up the fields in the frame to default values. */
Xvoid Frame_Init ()
X  {
X  Default_Texture = Get_Texture();
X  Init_Viewpoint(&(Parsing_Frame_Ptr -> View_Point));
X  Parsing_Frame_Ptr -> Light_Sources = NULL;
X  Parsing_Frame_Ptr -> Objects = NULL;
X  Parsing_Frame_Ptr -> Atmosphere_IOR = 1.0;
X  Parsing_Frame_Ptr -> Antialias_Threshold = Antialias_Threshold;
X  Parsing_Frame_Ptr -> Fog_Distance = 0.0;
X  Make_Colour (&(Parsing_Frame_Ptr->Fog_Colour), 0.0, 0.0, 0.0);
X  }
X
X/* Allocate and initialize a composite object. */
XCOMPOSITE *Get_Composite_Object()
X  {
X  COMPOSITE *New_Composite;
X
X  if ((New_Composite = (COMPOSITE *) malloc (sizeof (COMPOSITE)))
X        == NULL)
X    Error ("Cannot allocate object");
X
X  New_Composite -> Objects = NULL;
X  New_Composite -> Next_Object = NULL;
X  New_Composite -> Next_Light_Source = NULL;
X  New_Composite -> Bounding_Shapes = NULL;
X  New_Composite -> Type = COMPOSITE_TYPE;
X  New_Composite -> Methods = &Composite_Methods;
X  return (New_Composite);
X  }
X
X/* Allocate and initialize a sphere. */
XSPHERE *Get_Sphere_Shape()
X  {
X  SPHERE *New_Shape;
X
X  if ((New_Shape = (SPHERE *) malloc (sizeof (SPHERE))) == NULL)
X    Error ("Cannot allocate shape");
X
X  Make_Vector (&(New_Shape -> Center), 0.0, 0.0, 0.0);
X  New_Shape->Radius = 1.0;
X  New_Shape->Radius_Squared = 1.0;
X  New_Shape->Inverse_Radius = 1.0;
X  New_Shape -> Type = SPHERE_TYPE;
X  New_Shape -> Next_Object = NULL;
X  New_Shape -> Methods = &Sphere_Methods;
X  New_Shape -> VPCached = FALSE;
X  New_Shape -> Inverted = FALSE;
X  return (New_Shape);
X  }
X
X/* Allocate and initialize a quadric surface. */
XQUADRIC *Get_Quadric_Shape()
X  {
X  QUADRIC *New_Shape;
X
X  if ((New_Shape = (QUADRIC *) malloc (sizeof (QUADRIC))) == NULL)
X    Error ("Cannot allocate shape");
X
X  Make_Vector (&(New_Shape -> Object_2_Terms), 1.0, 1.0, 1.0);
X  Make_Vector (&(New_Shape -> Object_Mixed_Terms), 0.0, 0.0, 0.0);
X  Make_Vector (&(New_Shape -> Object_Terms), 0.0, 0.0, 0.0);
X  New_Shape -> Object_Constant = 1.0;
X  New_Shape -> Object_VP_Constant = HUGE_VAL;
X  New_Shape -> Constant_Cached = FALSE;
X  New_Shape -> Non_Zero_Square_Term = FALSE;
X  New_Shape -> Type = QUADRIC_TYPE;
X  New_Shape -> Next_Object = NULL;
X  New_Shape -> Methods = &Quadric_Methods;
X  return (New_Shape);
X  }
X
X/* Allocate and initialize a plane. */
XPLANE *Get_Plane_Shape()
X  {
X  PLANE *New_Shape;
X
X  if ((New_Shape = (PLANE *) malloc (sizeof (PLANE))) == NULL)
X    Error ("Cannot allocate shape");
X
X  Make_Vector (&(New_Shape -> Normal_Vector), 0.0, 1.0, 0.0);
X  New_Shape->Distance = 0.0;
X  New_Shape -> Type = PLANE_TYPE;
X  New_Shape -> Next_Object = NULL;
X  New_Shape -> Methods = &Plane_Methods;
X  New_Shape -> VPCached = 0;
X  return (New_Shape);
X  }
X
X/* Allocate and initialize a triangle. */
XTRIANGLE *Get_Triangle_Shape()
X  {
X  TRIANGLE *New_Shape;
X
X  if ((New_Shape = (TRIANGLE *) malloc (sizeof (TRIANGLE))) == NULL)
X    Error ("Cannot allocate shape");
X
X  Make_Vector (&(New_Shape -> Normal_Vector), 0.0, 1.0, 0.0);
X  Make_Vector (&(New_Shape -> P1), 0.0, 0.0, 0.0);
X  Make_Vector (&(New_Shape -> P2), 1.0, 0.0, 0.0);
X  Make_Vector (&(New_Shape -> P3), 0.0, 1.0, 0.0);
X  New_Shape->Distance = 0.0;
X  New_Shape->Inverted = FALSE;
X  New_Shape -> Type = TRIANGLE_TYPE;
X  New_Shape -> Next_Object = NULL;
X  New_Shape -> Methods = &Triangle_Methods;
X  New_Shape -> VPCached = FALSE;
X  return (New_Shape);
X  }
X
X/* Allocate and initialize a smooth triangle. */
XSMOOTH_TRIANGLE *Get_Smooth_Triangle_Shape()
X  {
X  SMOOTH_TRIANGLE *New_Shape;
X
X  if ((New_Shape = (SMOOTH_TRIANGLE *) malloc (sizeof (SMOOTH_TRIANGLE))) == NULL)
X    Error ("Cannot allocate shape");
X
X  Make_Vector (&(New_Shape -> Normal_Vector), 0.0, 1.0, 0.0);
X  Make_Vector (&(New_Shape -> P1), 0.0, 0.0, 0.0);
X  Make_Vector (&(New_Shape -> P2), 1.0, 0.0, 0.0);
X  Make_Vector (&(New_Shape -> P3), 0.0, 1.0, 0.0);
X  Make_Vector (&(New_Shape -> N1), 0.0, 1.0, 0.0);
X  Make_Vector (&(New_Shape -> DN12), 0.0, 1.0, 0.0);
X  Make_Vector (&(New_Shape -> DN13), 0.0, 1.0, 0.0);
X  New_Shape->Distance = 0.0;
X  New_Shape -> Type = SMOOTH_TRIANGLE_TYPE;
X  New_Shape->Inverted = FALSE;
X  New_Shape -> Next_Object = NULL;
X  New_Shape -> Methods = &Smooth_Triangle_Methods;
X  New_Shape -> VPCached = 0;
X  return (New_Shape);
X  }
X
XCSG_SHAPE *Get_CSG_Shape()
X  {
X  CSG_SHAPE *New_Shape;
X
X  if ((New_Shape = (CSG_SHAPE *) malloc (sizeof (CSG_SHAPE))) == NULL)
X    Error ("Cannot allocate shape");
X
X  New_Shape -> Parent_Object = NULL;
X  New_Shape -> Next_Object = NULL;
X  New_Shape -> Shapes = NULL;
X  return (New_Shape);
X  }
X
XCSG_SHAPE *Get_CSG_Union()
X  {
X  CSG_SHAPE *New_Shape;
X
X  New_Shape = Get_CSG_Shape();
X  New_Shape -> Methods = &CSG_Union_Methods;
X  New_Shape -> Type = CSG_UNION_TYPE;
X  return (New_Shape);
X  }
X
XCSG_SHAPE *Get_CSG_Intersection()
X  {
X  CSG_SHAPE *New_Shape;
X
X  New_Shape = Get_CSG_Shape();
X  New_Shape -> Methods = &CSG_Intersection_Methods;
X  New_Shape -> Type = CSG_INTERSECTION_TYPE;
X  return (New_Shape);
X  }
X
XOBJECT *Get_Object ()
X  {
X  OBJECT *New_Object;
X
X  if ((New_Object = (OBJECT *) malloc (sizeof (OBJECT))) == NULL)
X    Error ("Cannot allocate object");
X
X  Make_Vector (&(New_Object -> Object_Center), 0.0, 0.0, 0.0);
X
X  New_Object -> Next_Object = NULL;
X  New_Object -> Next_Light_Source = NULL;
X  New_Object -> Shape = NULL;
X  New_Object -> Bounding_Shapes = NULL;
X  New_Object -> Object_Texture = Default_Texture;
X
X  Make_Colour (&New_Object->Object_Colour, 0.0, 0.0, 0.0);
X
X  New_Object -> Light_Source_Flag = FALSE;
X  New_Object -> Transparency = FALSE;
X  New_Object -> Type = OBJECT_TYPE;
X  New_Object -> Methods = &Basic_Object_Methods;
X  return (New_Object);
X  }
X
XTEXTURE *Get_Texture ()
X   {
X   TEXTURE *New_Texture;
X
X   if ((New_Texture = (TEXTURE *) malloc (sizeof (TEXTURE))) == NULL)
X     Error ("Cannot allocate object");
X
X   New_Texture -> Object_Reflection = 0.0;
X   New_Texture -> Object_Ambient = 0.3;
X   New_Texture -> Object_Diffuse = 0.7;
X   New_Texture -> Object_Brilliance = 1.0;
X   New_Texture -> Object_Specular = 0.0;
X   New_Texture -> Object_Roughness = 0.05;
X   New_Texture -> Object_Phong = 0.0;
X   New_Texture -> Object_PhongSize = 40;
X
X   New_Texture -> Texture_Randomness= 0.0;
X   New_Texture -> Bump_Amount = 0.0;
X   New_Texture -> Phase = 0.0;
X   New_Texture -> Frequency = 1.0;
X   New_Texture -> Texture_Number = 0;
X   New_Texture -> Texture_Transformation = NULL;
X   New_Texture -> Bump_Number = NO_BUMPS;
X   New_Texture -> Turbulence = 0.0;
X   New_Texture -> Colour_Map = NULL;
X   New_Texture -> Once_Flag = FALSE;
X   Make_Colour (&New_Texture -> Colour1, 0.0, 0.0, 0.0);
X   Make_Colour (&New_Texture -> Colour2, 0.0, 0.0, 0.0);
X   Make_Vector (&New_Texture->Texture_Gradient, 0.0, 0.0, 0.0);
X
X   New_Texture -> Object_Index_Of_Refraction = 1.0;
X   New_Texture -> Object_Refraction = 0.0;
X
X   return (New_Texture);
X   }
X
XVIEWPOINT *Get_Viewpoint ()
X  {
X  VIEWPOINT *New_Viewpoint;
X
X  if ((New_Viewpoint = (VIEWPOINT *)malloc (sizeof (VIEWPOINT)))
X        == NULL)
X    Error ("Cannot allocate viewpoint");
X
X  Init_Viewpoint (New_Viewpoint);
X  return (New_Viewpoint);
X  }
X
XCOLOUR *Get_Colour ()
X  {
X  COLOUR *New_Colour;
X
X  if ((New_Colour = (COLOUR *) malloc (sizeof (COLOUR))) == NULL)
X    Error ("Cannot allocate colour");
X
X  Make_Colour (New_Colour, 0.0, 0.0, 0.0);
X  return (New_Colour);
X  }
X
XVECTOR *Get_Vector ()
X  {
X  VECTOR *New_Vector;
X
X  if ((New_Vector = (VECTOR *) malloc (sizeof (VECTOR))) == NULL)
X    Error ("Cannot allocate vector");
X
X  New_Vector -> x = 0.0;
X  New_Vector -> y = 0.0;
X  New_Vector -> z = 0.0;
X  return (New_Vector);
X  }
X
XDBL *Get_Float ()
X  {
X  DBL *New_Float;
X
X  if ((New_Float = (DBL *) malloc (sizeof (DBL))) == NULL)
X    Error ("Cannot allocate float");
X
X  *New_Float = 0.0;
X  return (New_Float);
X  }
X
XTRANSFORMATION *Get_Transformation()
X  {
X  TRANSFORMATION *New_Transformation;
X
X  if ((New_Transformation =
X        (TRANSFORMATION *) malloc (sizeof (TRANSFORMATION))) == NULL)
X    Error ("Cannot allocate transformation");
X
X  MIdentity ((MATRIX *) &(New_Transformation -> matrix[0][0]));
X  MIdentity ((MATRIX *) &(New_Transformation -> inverse[0][0]));
X  return (New_Transformation);
X  }
X
X/* Parse a float.  Doesn't handle exponentiation. */
XDBL Parse_Float ()
X  {
X  DBL Local_Float;
X  CONSTANT Constant_Id;
X  register int Negative, Sign_Parsed;
X
X  Negative = FALSE;
X  Sign_Parsed = FALSE;
X
X  EXPECT
X    CASE (IDENTIFIER_TOKEN)
X      if ((Constant_Id = Find_Constant()) != -1)
X        if (Constants[(int)Constant_Id].Constant_Type == FLOAT_CONSTANT)
X          {
X          Local_Float = *((DBL *) Constants[(int)Constant_Id].Constant_Data);
X          if (Negative)
X            Local_Float *= -1.0;
X          }
X        else
X          Type_Error ();
X      else
X        Undeclared ();
X      EXIT
X    END_CASE
X
X    CASE (PLUS_TOKEN)
X      if (Sign_Parsed)
X        Parse_Error (FLOAT_TOKEN);
X      Sign_Parsed = TRUE;
X    END_CASE
X
X    CASE (DASH_TOKEN)
X      if (Sign_Parsed)
X        Parse_Error (FLOAT_TOKEN);
X      Negative = TRUE;
X      Sign_Parsed = TRUE;
X    END_CASE
X
X    CASE (FLOAT_TOKEN)
X      Local_Float = Token.Token_Float;
X      if (Negative)
X        Local_Float *= -1.0;
X      EXIT
X    END_CASE
X
X    OTHERWISE
X      Parse_Error (FLOAT_TOKEN);
X    END_CASE
X  END_EXPECT
X
X  return (Local_Float);
X  }
X
Xvoid Parse_Vector (Given_Vector)
X  VECTOR *Given_Vector;
X  {
X  CONSTANT Constant_Id;
X
X  EXPECT
X    CASE (IDENTIFIER_TOKEN)
X      if ((Constant_Id = Find_Constant()) != -1)
X        if (Constants[(int)Constant_Id].Constant_Type == VECTOR_CONSTANT)
X          *Given_Vector = *((VECTOR *) Constants[(int)Constant_Id].Constant_Data);
X        else
X          Type_Error ();
X      else
X        Undeclared ();
X      EXIT
X    END_CASE
X
X    CASE (LEFT_ANGLE_TOKEN)
X      (Given_Vector -> x) = Parse_Float();
X      (Given_Vector -> y) = Parse_Float();
X      (Given_Vector -> z) = Parse_Float();
X      GET (RIGHT_ANGLE_TOKEN);
X      EXIT
X    END_CASE
X
X    OTHERWISE
X      Parse_Error (LEFT_ANGLE_TOKEN);
X    END_CASE
X  END_EXPECT
X  }
X
Xvoid Parse_Colour (Given_Colour)
X  COLOUR *Given_Colour;
X  {
X  CONSTANT Constant_Id;
X
X  Make_Colour (Given_Colour, 0.0, 0.0, 0.0);
X  EXPECT
X    CASE (IDENTIFIER_TOKEN)
X      if ((Constant_Id = Find_Constant()) != -1)
X        if (Constants[(int)Constant_Id].Constant_Type == COLOUR_CONSTANT)
X          *Given_Colour = *((COLOUR *) Constants[(int)Constant_Id].Constant_Data);
X        else
X          Type_Error ();
X      else
X        Undeclared ();
X    END_CASE
X
X    CASE (RED_TOKEN)
X      (Given_Colour -> Red) = Parse_Float();
X    END_CASE
X
X    CASE (GREEN_TOKEN)
X      (Given_Colour -> Green) = Parse_Float();
X    END_CASE
X
X    CASE (BLUE_TOKEN)
X      (Given_Colour -> Blue) = Parse_Float();
X    END_CASE
X
X    CASE (ALPHA_TOKEN)
X      (Given_Colour -> Alpha) = Parse_Float();
X    END_CASE
X
X    OTHERWISE
X      UNGET
X      EXIT
X    END_CASE
X  END_EXPECT
X  }
X
XCOLOUR_MAP *Parse_Colour_Map ()
X   {
X#define MAX_ENTRIES 20
X   COLOUR_MAP *New_Colour_Map;
X   register int i;
X
X   New_Colour_Map = (COLOUR_MAP *)
X                        malloc (sizeof (COLOUR_MAP));
X
X   if (New_Colour_Map == NULL)
X      Error ("Not enough memory for colour map");
X
X   New_Colour_Map -> Colour_Map_Entries = (COLOUR_MAP_ENTRY *)
X                  malloc(MAX_ENTRIES * sizeof (COLOUR_MAP_ENTRY));
X
X   if (New_Colour_Map -> Colour_Map_Entries == NULL)
X      Error ("Not enough memory for colour map");
X
X   i = 0;
X   EXPECT
X      CASE (LEFT_SQUARE_TOKEN)
X         New_Colour_Map -> Colour_Map_Entries [i].start = Parse_Float();
X         New_Colour_Map -> Colour_Map_Entries [i].end = Parse_Float();
X         GET (COLOUR_TOKEN);
X         Parse_Colour (&(New_Colour_Map->Colour_Map_Entries[i].Start_Colour));
X         GET (COLOUR_TOKEN);
X         Parse_Colour (&(New_Colour_Map->Colour_Map_Entries[i].End_Colour));
X         i++;
X         if (i > MAX_ENTRIES)
X            Error ("Colour_Map too long");
X         GET (RIGHT_SQUARE_TOKEN);
X      END_CASE
X
X      CASE2 (END_COLOUR_MAP_TOKEN, END_COLOR_MAP_TOKEN)
X          New_Colour_Map -> Number_Of_Entries = i;
X          EXIT
X      END_CASE
X
X      OTHERWISE
X         Parse_Error (END_COLOUR_MAP_TOKEN);
X      END_CASE
X   END_EXPECT
X   return (New_Colour_Map);
X   }
X
XTEXTURE *Copy_Texture (Texture)
X   TEXTURE *Texture;
X   {
X   TEXTURE *New_Texture;
X   New_Texture = Get_Texture();
X   *New_Texture = *Texture;
X   if (New_Texture->Texture_Transformation) {
X      New_Texture->Texture_Transformation = (TRANSFORMATION *) malloc (sizeof (TRANSFORMATION));
X      *New_Texture->Texture_Transformation = *Texture->Texture_Transformation;
X      }
X   return (New_Texture);
X   }
X
XTEXTURE *Parse_Texture (Old_Texture)
X   TEXTURE *Old_Texture;
X   {
X   VECTOR Local_Vector;
X   TRANSFORMATION Local_Transformation;
X   CONSTANT Constant_Id;
X   TEXTURE *Texture;
X   int Texture_Constant;
X
X   Texture = Old_Texture;
X   Texture_Constant = TRUE;
X
X   EXPECT
X      CASE (IDENTIFIER_TOKEN)
X         if ((Constant_Id = Find_Constant()) != -1)
X            if (Constants[(int)Constant_Id].Constant_Type == TEXTURE_CONSTANT) {
X               Texture = ((TEXTURE *) Constants[(int)Constant_Id].Constant_Data);
X               Texture_Constant = TRUE;
X               }
X            else
X               Type_Error ();
X         else
X            Undeclared ();
X      END_CASE
X
X      CASE (FLOAT_TOKEN)
X         UNGET
X         if (Texture_Constant) {
X            Texture = Copy_Texture(Texture);
X            Texture_Constant = FALSE;
X            }
X         Texture -> Texture_Randomness = Parse_Float();
X      END_CASE
X
X      CASE (ONCE_TOKEN)
X         if (Texture_Constant) {
X            Texture = Copy_Texture(Texture);
X            Texture_Constant = FALSE;
X            }
X         Texture->Once_Flag = TRUE;
X      END_CASE
X
X      CASE (TURBULENCE_TOKEN)
X         if (Texture_Constant) {
X            Texture = Copy_Texture(Texture);
X            Texture_Constant = FALSE;
X            }
X          Texture -> Turbulence = Parse_Float();
X      END_CASE
X
X      CASE (BOZO_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X         Texture -> Texture_Number = BOZO_TEXTURE;
X      END_CASE
X
X      CASE (CHECKER_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X         Texture -> Texture_Number = CHECKER_TEXTURE;
X         EXPECT
X            CASE (COLOUR_TOKEN)
X               Parse_Colour (&(Texture -> Colour1));
X               GET (COLOUR_TOKEN);
X               Parse_Colour (&(Texture -> Colour2));
X            END_CASE
X
X            OTHERWISE
X               UNGET
X               EXIT
X            END_CASE
X         END_EXPECT
X      END_CASE
X
X      CASE (MARBLE_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X         Texture -> Texture_Number = MARBLE_TEXTURE;
X      END_CASE
X
X      CASE (WOOD_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X         Texture -> Texture_Number = WOOD_TEXTURE;
X      END_CASE
X
X      CASE (SPOTTED_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X         Texture -> Texture_Number = SPOTTED_TEXTURE;
X      END_CASE
X
X      CASE (AGATE_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X         Texture -> Texture_Number = AGATE_TEXTURE;
X      END_CASE
X
X      CASE (GRANITE_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X         Texture -> Texture_Number = GRANITE_TEXTURE;
X      END_CASE
X
X       CASE (GRADIENT_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X     Texture -> Texture_Number = GRADIENT_TEXTURE;
X     Parse_Vector (&(Texture -> Texture_Gradient));
X       END_CASE
X
X      CASE (AMBIENT_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X         (Texture -> Object_Ambient) = Parse_Float ();
X      END_CASE
X
X      CASE (BRILLIANCE_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X         (Texture -> Object_Brilliance) = Parse_Float ();
X      END_CASE
X
X      CASE (ROUGHNESS_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X         (Texture -> Object_Roughness) = Parse_Float ();
X         if (Texture -> Object_Roughness > 1.0)
X            Texture -> Object_Roughness = 1.0;
X         if (Texture -> Object_Roughness < 0.001)
X            Texture -> Object_Roughness = 0.001;
X      END_CASE
X
X      CASE (PHONGSIZE_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X         (Texture -> Object_PhongSize) = Parse_Float ();
X         if (Texture -> Object_PhongSize < 1.0)
X            Texture -> Object_PhongSize = 1.0;
X         if (Texture -> Object_PhongSize > 100)
X            Texture -> Object_PhongSize = 100;
X      END_CASE
X
X      CASE (DIFFUSE_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X         (Texture -> Object_Diffuse) = Parse_Float ();
X      END_CASE
X
X      CASE (SPECULAR_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X         (Texture -> Object_Specular) = Parse_Float ();
X      END_CASE
X
X      CASE (PHONG_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X         (Texture -> Object_Phong) = Parse_Float ();
X      END_CASE
X
X      CASE (IOR_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X         (Texture -> Object_Index_Of_Refraction) = Parse_Float ();
X      END_CASE
X
X      CASE (REFRACTION_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X         (Texture -> Object_Refraction) = Parse_Float ();
X      END_CASE
X
X      CASE (REFLECTION_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X         (Texture -> Object_Reflection) = Parse_Float ();
X      END_CASE
X
X      CASE (IMAGEMAP_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X         Texture -> Texture_Number = IMAGEMAP_TEXTURE;
X         Texture->Image = (IMAGE *)malloc(sizeof(IMAGE));
X         Make_Vector (&Texture->Texture_Gradient, 1.0, -1.0, 0.0);
X         EXPECT
X            CASE (LEFT_ANGLE_TOKEN)
X                 UNGET
X                 Parse_Vector (&(Texture -> Texture_Gradient));
X            END_CASE
X
X            CASE (IFF_TOKEN)
X               GET (STRING_TOKEN);
X               read_iff_image(Texture->Image, Token.Token_String);
X               EXIT
X            END_CASE
X
X            CASE (GIF_TOKEN)
X               GET (STRING_TOKEN);
X               read_gif_image(Texture->Image, Token.Token_String);
X               EXIT
X            END_CASE
X
X            CASE (RAW_TOKEN)
X               GET (STRING_TOKEN);
X               read_raw_image(Texture->Image, Token.Token_String);
X               EXIT
X            END_CASE
X
X            OTHERWISE
X               Parse_Error (RAW_TOKEN);
X            END_CASE
X         END_EXPECT
X      END_CASE
X
X      CASE (WAVES_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X         Texture -> Bump_Number = WAVES;
X         Texture -> Bump_Amount = Parse_Float ();
X         EXPECT
X            CASE (PHASE_TOKEN)
X               Texture -> Phase = Parse_Float();
X               EXIT
X            END_CASE
X
X            OTHERWISE
X               UNGET
X               EXIT
X            END_CASE
X         END_EXPECT
X      END_CASE
X
X      CASE (FREQUENCY_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X         Texture -> Frequency = Parse_Float();
X      END_CASE
X
X      CASE (PHASE_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X         Texture -> Phase = Parse_Float();
X      END_CASE
X
X      CASE (RIPPLES_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X         Texture -> Bump_Number = RIPPLES;
X         Texture -> Bump_Amount = Parse_Float ();
X      END_CASE
X
X      CASE (WRINKLES_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X         Texture -> Bump_Number = WRINKLES;
X         Texture -> Bump_Amount = Parse_Float ();
X      END_CASE
X
X      CASE (BUMPS_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X         Texture -> Bump_Number = BUMPS;
X         Texture -> Bump_Amount = Parse_Float ();
X      END_CASE
X
X      CASE (DENTS_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X         Texture -> Bump_Number = DENTS;
X         Texture -> Bump_Amount = Parse_Float ();
X      END_CASE
X
X      CASE (TRANSLATE_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X         Parse_Vector (&Local_Vector);
X         if (!Texture -> Texture_Transformation)
X            Texture -> Texture_Transformation = Get_Transformation ();
X         Get_Translation_Transformation (&Local_Transformation,
X                                         &Local_Vector);
X         Compose_Transformations (Texture -> Texture_Transformation,
X                                  &Local_Transformation);
X      END_CASE
X
X      CASE (ROTATE_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X         Parse_Vector (&Local_Vector);
X         if (!Texture -> Texture_Transformation)
X            Texture -> Texture_Transformation = Get_Transformation ();
X         Get_Rotation_Transformation (&Local_Transformation,
X                                      &Local_Vector);
X         Compose_Transformations (Texture -> Texture_Transformation,
X                                  &Local_Transformation);
X      END_CASE
X
X      CASE (SCALE_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X         Parse_Vector (&Local_Vector);
X         if (!Texture -> Texture_Transformation)
X             Texture -> Texture_Transformation = Get_Transformation ();
X         Get_Scaling_Transformation (&Local_Transformation,
X                                     &Local_Vector);
X         Compose_Transformations (Texture -> Texture_Transformation,
X                                  &Local_Transformation);
X      END_CASE
X
X      CASE2 (COLOUR_MAP_TOKEN, COLOR_MAP_TOKEN)
X         if (Texture_Constant) {
X            Texture_Constant = FALSE;
X            Texture = Copy_Texture (Texture);
X            }
X         Texture -> Colour_Map = Parse_Colour_Map();
X      END_CASE
X
X      CASE (END_TEXTURE_TOKEN)
X         EXIT
X      END_CASE
X
X      OTHERWISE
X         Parse_Error (END_TEXTURE_TOKEN);
X      END_CASE
X   END_EXPECT
X   return (Texture);
X   }
X
XSHAPE *Parse_Sphere ()
X  {
X  SPHERE *Local_Shape;
X  CONSTANT Constant_Id;
X  VECTOR Local_Vector;
X
X  Local_Shape = NULL;
X
X  EXPECT
X     CASE (LEFT_ANGLE_TOKEN)
X       UNGET
X       Local_Shape = Get_Sphere_Shape();
X       Parse_Vector(&(Local_Shape -> Center));
X       Local_Shape -> Radius = Parse_Float();
X       Local_Shape -> Radius_Squared = Local_Shape -> Radius * Local_Shape -> Radius;
X       Local_Shape -> Inverse_Radius = 1.0 / Local_Shape -> Radius;
X       EXIT
X     END_CASE
X
X     CASE (IDENTIFIER_TOKEN)
X       if ((Constant_Id = Find_Constant()) != -1)
X         if (Constants[(int)Constant_Id].Constant_Type == SPHERE_CONSTANT)
X           Local_Shape = (SPHERE *)Copy((OBJECT *) Constants[(int)Constant_Id].Constant_Data);
X         else
X           Type_Error ();
X       else
X         Undeclared ();
X       EXIT
X     END_CASE
X
X     OTHERWISE
X        Parse_Error (LEFT_ANGLE_TOKEN);
X     END_CASE
X  END_EXPECT
X
X  EXPECT
X     CASE (END_SPHERE_TOKEN)
X        EXIT
X     END_CASE
X
X     CASE (TRANSLATE_TOKEN)
X        Parse_Vector (&Local_Vector);
X        Translate ((OBJECT *) Local_Shape, &Local_Vector);
X     END_CASE
X
X     CASE (ROTATE_TOKEN)
X        Parse_Vector (&Local_Vector);
X        Rotate ((OBJECT *) Local_Shape, &Local_Vector);
X     END_CASE
X
X     CASE (SCALE_TOKEN)
X        Parse_Vector (&Local_Vector);
X        Scale ((OBJECT *) Local_Shape, &Local_Vector);
X     END_CASE
X
X     CASE (INVERSE_TOKEN)
X        Invert ((OBJECT *) Local_Shape);
X     END_CASE
X
X     OTHERWISE
X        Parse_Error (END_SPHERE_TOKEN);
X     END_CASE
X  END_EXPECT
X
X  return ((SHAPE *) Local_Shape);
X  }
X
XSHAPE *Parse_Plane ()
X  {
X  PLANE *Local_Shape;
X  CONSTANT Constant_Id;
X  VECTOR Local_Vector;
X
X  Local_Shape = NULL;
X
X  EXPECT
X     CASE (LEFT_ANGLE_TOKEN)
X       UNGET
X       Local_Shape = Get_Plane_Shape();
X       Parse_Vector(&(Local_Shape -> Normal_Vector));
X       Local_Shape->Distance = Parse_Float();
X       Local_Shape->Distance *= -1.0;
X       EXIT
X     END_CASE
X
X     CASE (IDENTIFIER_TOKEN)
X       if ((Constant_Id = Find_Constant()) != -1)
X         if (Constants[(int)Constant_Id].Constant_Type == PLANE_CONSTANT)
X           Local_Shape = (PLANE *)Copy((OBJECT *) Constants[(int)Constant_Id].Constant_Data);
X         else
X           Type_Error ();
X       else
X         Undeclared ();
X       EXIT
X     END_CASE
X
X     OTHERWISE
X        Parse_Error (LEFT_ANGLE_TOKEN);
X     END_CASE
X  END_EXPECT
X
X  EXPECT
X     CASE (END_PLANE_TOKEN)
X        EXIT
X     END_CASE
X
X     CASE (TRANSLATE_TOKEN)
X        Parse_Vector (&Local_Vector);
X        Translate ((OBJECT *) Local_Shape, &Local_Vector);
X     END_CASE
X
X     CASE (ROTATE_TOKEN)
X        Parse_Vector (&Local_Vector);
X        Rotate ((OBJECT *) Local_Shape, &Local_Vector);
X     END_CASE
X
X     CASE (SCALE_TOKEN)
X        Parse_Vector (&Local_Vector);
X        Scale ((OBJECT *) Local_Shape, &Local_Vector);
X     END_CASE
X
X     CASE (INVERSE_TOKEN)
X        Invert ((OBJECT *) Local_Shape);
X     END_CASE
X
X     OTHERWISE
X        Parse_Error (END_PLANE_TOKEN);
X     END_CASE
X  END_EXPECT
X
X  return ((SHAPE *) Local_Shape);
X  }
X
XSHAPE *Parse_Triangle ()
X  {
X  TRIANGLE *Local_Shape;
X  CONSTANT Constant_Id;
X  VECTOR Local_Vector;
X
X  Local_Shape = NULL;
X
X  EXPECT
X     CASE (LEFT_ANGLE_TOKEN)
X       UNGET
X       Local_Shape = Get_Triangle_Shape();
X       Parse_Vector (&Local_Shape->P1);
X       Parse_Vector (&Local_Shape->P2);
X       Parse_Vector (&Local_Shape->P3);
X       if (!Compute_Triangle (Local_Shape)) {
X          printf ("Degenerate triangle on line %d.  Please remove.\n",
X                  Token.Token_Line_No);
X          Degenerate_Triangles = TRUE;
X          }
X       EXIT
X     END_CASE
X
X     CASE (IDENTIFIER_TOKEN)
X       if ((Constant_Id = Find_Constant()) != -1)
X         if (Constants[(int)Constant_Id].Constant_Type == TRIANGLE_CONSTANT)
X           Local_Shape = (TRIANGLE *)Copy((OBJECT *) Constants[(int)Constant_Id].Constant_Data);
X         else
X           Type_Error ();
X       else
X         Undeclared ();
X       EXIT
X     END_CASE
X
X     OTHERWISE
X        Parse_Error (LEFT_ANGLE_TOKEN);
X     END_CASE
X  END_EXPECT
X
X  EXPECT
X     CASE (END_TRIANGLE_TOKEN)
X        EXIT
X     END_CASE
X
X     CASE (TRANSLATE_TOKEN)
X        Parse_Vector (&Local_Vector);
X        Translate ((OBJECT *) Local_Shape, &Local_Vector);
X     END_CASE
X
X     CASE (ROTATE_TOKEN)
X        Parse_Vector (&Local_Vector);
X        Rotate ((OBJECT *) Local_Shape, &Local_Vector);
X     END_CASE
X
X     CASE (SCALE_TOKEN)
X        Parse_Vector (&Local_Vector);
X        Scale ((OBJECT *) Local_Shape, &Local_Vector);
X     END_CASE
X
X     CASE (INVERSE_TOKEN)
X        Invert ((OBJECT *) Local_Shape);
X     END_CASE
X
X     OTHERWISE
X        Parse_Error (END_TRIANGLE_TOKEN);
X     END_CASE
X  END_EXPECT
X
X  return ((SHAPE *) Local_Shape);
X  }
X
XSHAPE *Parse_Smooth_Triangle ()
X  {
X  SMOOTH_TRIANGLE *Local_Shape;
X  CONSTANT Constant_Id;
X  VECTOR Local_Vector;
X
X  Local_Shape = NULL;
X
X  EXPECT
X     CASE (LEFT_ANGLE_TOKEN)
X       UNGET
X       Local_Shape = (SMOOTH_TRIANGLE *) Get_Smooth_Triangle_Shape();
X       Parse_Vector (&Local_Shape->P1);
X       Parse_Vector (&Local_Shape->N1);
X       Parse_Vector (&Local_Shape->P2);
X       Parse_Vector (&Local_Vector);
X       VSub (Local_Shape->DN12, Local_Vector, Local_Shape->N1);
X       Parse_Vector (&Local_Shape->P3);
X       Parse_Vector (&Local_Vector);
X       VSub (Local_Shape->DN13, Local_Vector, Local_Shape->N1);
X       if (!Compute_Triangle ((TRIANGLE *) Local_Shape)) {
X          printf ("Degenerate triangle on line %d.  Please remove.\n",
X                  Token.Token_Line_No);
X          Degenerate_Triangles = TRUE;
X          }
X       EXIT
X     END_CASE
X
X     CASE (IDENTIFIER_TOKEN)
X       if ((Constant_Id = Find_Constant()) != -1)
X         if (Constants[(int)Constant_Id].Constant_Type == SMOOTH_TRIANGLE_CONSTANT)
X           Local_Shape = (SMOOTH_TRIANGLE *)Copy((OBJECT *) Constants[(int)Constant_Id].Constant_Data);
X         else
X           Type_Error ();
X       else
X         Undeclared ();
X       EXIT
X     END_CASE
X
X     CASE (TRANSLATE_TOKEN)
X        Parse_Vector (&Local_Vector);
X        Translate ((OBJECT *) Local_Shape, &Local_Vector);
X     END_CASE
X
X     CASE (ROTATE_TOKEN)
X        Parse_Vector (&Local_Vector);
X        Rotate ((OBJECT *) Local_Shape, &Local_Vector);
X     END_CASE
X
X     CASE (SCALE_TOKEN)
X        Parse_Vector (&Local_Vector);
X        Scale ((OBJECT *) Local_Shape, &Local_Vector);
X     END_CASE
X
X     CASE (INVERSE_TOKEN)
X        Invert ((OBJECT *) Local_Shape);
X     END_CASE
X
X     OTHERWISE
X        Parse_Error (LEFT_ANGLE_TOKEN);
X     END_CASE
X  END_EXPECT
X
X  EXPECT
X     CASE (END_TRIANGLE_TOKEN)
X        EXIT
X     END_CASE
X
X     OTHERWISE
X        Parse_Error (END_TRIANGLE_TOKEN);
X     END_CASE
X  END_EXPECT
X
X  return ((SHAPE *) Local_Shape);
X  }
X
XSHAPE *Parse_Quadric ()
X  {
X  QUADRIC *Local_Shape;
X  VECTOR Local_Vector;
X  CONSTANT Constant_Id;
X
X  Local_Shape = NULL;
X
X  EXPECT
X     CASE (LEFT_ANGLE_TOKEN)
X       UNGET
X       Local_Shape = Get_Quadric_Shape();
X       Parse_Vector(&(Local_Shape -> Object_2_Terms));
X       Parse_Vector(&(Local_Shape -> Object_Mixed_Terms));
X       Parse_Vector(&(Local_Shape -> Object_Terms));
X       (Local_Shape -> Object_Constant) = Parse_Float();
X       Local_Shape -> Non_Zero_Square_Term =
X         !((Local_Shape -> Object_2_Terms.x == 0.0)
X          && (Local_Shape -> Object_2_Terms.y == 0.0)
X          && (Local_Shape -> Object_2_Terms.z == 0.0)
X          && (Local_Shape -> Object_Mixed_Terms.x == 0.0)
X          && (Local_Shape -> Object_Mixed_Terms.y == 0.0)
X          && (Local_Shape -> Object_Mixed_Terms.z == 0.0));
X       EXIT
X     END_CASE
X
X     CASE (IDENTIFIER_TOKEN)
X       if ((Constant_Id = Find_Constant()) != -1)
X         if (Constants[(int)Constant_Id].Constant_Type == QUADRIC_CONSTANT)
X           Local_Shape = (QUADRIC *)Copy((OBJECT *) Constants[(int)Constant_Id].Constant_Data);
X         else
X           Type_Error ();
X       else
X         Undeclared ();
X       EXIT
X     END_CASE
X
X     OTHERWISE
X        Parse_Error (LEFT_ANGLE_TOKEN);
X     END_CASE
X  END_EXPECT
X
X  EXPECT
X     CASE (END_QUADRIC_TOKEN)
X        EXIT
X     END_CASE
X
X     CASE (TRANSLATE_TOKEN)
X        Parse_Vector (&Local_Vector);
X        Translate ((OBJECT *) Local_Shape, &Local_Vector);
X     END_CASE
X
X     CASE (ROTATE_TOKEN)
X        Parse_Vector (&Local_Vector);
X        Rotate ((OBJECT *) Local_Shape, &Local_Vector);
X     END_CASE
X
X     CASE (SCALE_TOKEN)
X        Parse_Vector (&Local_Vector);
X        Scale ((OBJECT *) Local_Shape, &Local_Vector);
X     END_CASE
X
X     CASE (INVERSE_TOKEN)
X        Invert ((OBJECT *) Local_Shape);
X     END_CASE
X
X     OTHERWISE
X        Parse_Error (END_QUADRIC_TOKEN);
X     END_CASE
X  END_EXPECT
X
X  return ((SHAPE *) Local_Shape);
X  }
X
XCSG_SHAPE *Parse_CSG (type, Parent_Object)
X  int type;
X  OBJECT *Parent_Object;
X  {
X  CSG_SHAPE *Container;
X  SHAPE *Local_Shape;
X  VECTOR Local_Vector;
X  CONSTANT Constant_Id;
X  int First_Shape_Parsed = FALSE;
X
X  if (type == CSG_UNION_TYPE)
X    Container = Get_CSG_Union ();
X
X  else if ((type == CSG_INTERSECTION_TYPE) || (type == CSG_DIFFERENCE_TYPE))
X    Container = Get_CSG_Intersection ();
X
X  Container -> Parent_Object = Parent_Object;
X
X  EXPECT
X     CASE (IDENTIFIER_TOKEN)
X       if ((Constant_Id = Find_Constant()) != -1)
X         if ((Constants[(int)Constant_Id].Constant_Type == CSG_INTERSECTION_CONSTANT)
X             || (Constants[(int)Constant_Id].Constant_Type == CSG_UNION_CONSTANT)
X             || (Constants[(int)Constant_Id].Constant_Type == CSG_DIFFERENCE_CONSTANT)) {
X           free (Container);
X           Container = (CSG_SHAPE *) Copy ((OBJECT *) Constants[(int)Constant_Id].Constant_Data);
X           Set_CSG_Parents(Container, Parent_Object);
X           }
X         else
X           Type_Error ();
X       else
X         Undeclared ();
X     END_CASE
X
X     CASE (SPHERE_TOKEN)
X       Local_Shape = Parse_Sphere ();
X       Local_Shape -> Parent_Object = Parent_Object;
X       if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
X          Invert ((OBJECT *) Local_Shape);
X       First_Shape_Parsed = TRUE;
X       Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
X               (OBJECT **) &(Container -> Shapes));
X     END_CASE
X
X     CASE (PLANE_TOKEN)
X       Local_Shape = Parse_Plane ();
X       Local_Shape -> Parent_Object = Parent_Object;
X       if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
X          Invert ((OBJECT *) Local_Shape);
X       First_Shape_Parsed = TRUE;
X       Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
X               (OBJECT **) &(Container -> Shapes));
X     END_CASE
X
X     CASE (TRIANGLE_TOKEN)
X       Local_Shape = Parse_Triangle ();
X       Local_Shape -> Parent_Object = Parent_Object;
X       if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
X          Invert ((OBJECT *) Local_Shape);
X       First_Shape_Parsed = TRUE;
X       Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
X               (OBJECT **) &(Container -> Shapes));
X     END_CASE
X
X     CASE (SMOOTH_TRIANGLE_TOKEN)
X       Local_Shape = Parse_Smooth_Triangle ();
X       Local_Shape -> Parent_Object = Parent_Object;
X       if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
X          Invert ((OBJECT *) Local_Shape);
X       First_Shape_Parsed = TRUE;
X       Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
X               (OBJECT **) &(Container -> Shapes));
X     END_CASE
X
X     CASE (QUADRIC_TOKEN)
X       Local_Shape = Parse_Quadric ();
X       Local_Shape -> Parent_Object = Parent_Object;
X       if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
X          Invert ((OBJECT *) Local_Shape);
X       First_Shape_Parsed = TRUE;
X       Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
X               (OBJECT **) &(Container -> Shapes));
X     END_CASE
X
X     CASE (UNION_TOKEN)
X       Local_Shape = (SHAPE *) Parse_CSG (CSG_UNION_TYPE, Parent_Object);
X       if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
X          Invert ((OBJECT *) Local_Shape);
X       First_Shape_Parsed = TRUE;
X       Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
X               (OBJECT **) &(Container -> Shapes));
X     END_CASE
X
X     CASE (INTERSECTION_TOKEN)
X       Local_Shape = (SHAPE *) Parse_CSG (CSG_INTERSECTION_TYPE, Parent_Object);
X       if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
X          Invert ((OBJECT *) Local_Shape);
X       First_Shape_Parsed = TRUE;
X       Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
X               (OBJECT **) &(Container -> Shapes));
X     END_CASE
X
X     CASE (DIFFERENCE_TOKEN)
X       Local_Shape = (SHAPE *) Parse_CSG (CSG_DIFFERENCE_TYPE, Parent_Object);
X       if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
X          Invert ((OBJECT *) Local_Shape);
X       First_Shape_Parsed = TRUE;
X       Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
X               (OBJECT **) &(Container -> Shapes));
X     END_CASE
X
X     OTHERWISE
X        UNGET
X        EXIT
X     END_CASE
X  END_EXPECT
X
X  EXPECT
X     CASE3 (END_UNION_TOKEN, END_INTERSECTION_TOKEN, END_DIFFERENCE_TOKEN)
X        EXIT
X     END_CASE
X
X     CASE (TRANSLATE_TOKEN)
X        Parse_Vector (&Local_Vector);
X        Translate((OBJECT *) Container, &Local_Vector);
X     END_CASE
X
X     CASE (ROTATE_TOKEN)
X        Parse_Vector (&Local_Vector);
X        Rotate ((OBJECT *) Container, &Local_Vector);
X     END_CASE
X
X     CASE (SCALE_TOKEN)
X        Parse_Vector (&Local_Vector);
X        Scale ((OBJECT *) Container, &Local_Vector);
X     END_CASE
X
X     CASE (INVERSE_TOKEN)
X        Invert ((OBJECT *) Container);
X     END_CASE
X
X     OTHERWISE
X        Parse_Error (END_QUADRIC_TOKEN);
X     END_CASE
X  END_EXPECT
X
X  return ((CSG_SHAPE *) Container);
X  }
X
XSHAPE *Parse_Shape (Object)
X  OBJECT *Object;
X  {
X  SHAPE *Local_Shape;
X
X  EXPECT
X    CASE (SPHERE_TOKEN)
X      Local_Shape = Parse_Sphere ();
X      Local_Shape -> Parent_Object = Object;
X      EXIT
X    END_CASE
X
X    CASE (PLANE_TOKEN)
X      Local_Shape = Parse_Plane ();
X      Local_Shape -> Parent_Object = Object;
X      EXIT
X    END_CASE
X
X    CASE (TRIANGLE_TOKEN)
X      Local_Shape = Parse_Triangle ();
X      Local_Shape -> Parent_Object = Object;
X      EXIT
X    END_CASE
X
X    CASE (SMOOTH_TRIANGLE_TOKEN)
X      Local_Shape = Parse_Smooth_Triangle ();
X      Local_Shape -> Parent_Object = Object;
X      EXIT
X    END_CASE
X
X    CASE (QUADRIC_TOKEN)
X      Local_Shape = Parse_Quadric ();
X      Local_Shape -> Parent_Object = Object;
X      EXIT
X    END_CASE
X
X    CASE (UNION_TOKEN)
X      Local_Shape = (SHAPE *) Parse_CSG (CSG_UNION_TYPE, Object);
X      EXIT
X    END_CASE
X
X    CASE (INTERSECTION_TOKEN)
X      Local_Shape = (SHAPE *) Parse_CSG (CSG_INTERSECTION_TYPE, Object);
X      EXIT
X    END_CASE
X
X    CASE (DIFFERENCE_TOKEN)
X      Local_Shape = (SHAPE *) Parse_CSG (CSG_DIFFERENCE_TYPE, Object);
X      EXIT
X    END_CASE
X
X    OTHERWISE
X       Parse_Error (QUADRIC_TOKEN);
X    END_CASE
X  END_EXPECT
X  return (Local_Shape);
X  }
X
XOBJECT *Parse_Object ()
X  {
X  OBJECT *Object;
X  SHAPE *Local_Shape;
X  VECTOR Local_Vector;
X  CONSTANT Constant_Id;
X  int i;
X
X  Object = NULL;
X
X  EXPECT
X    CASE (IDENTIFIER_TOKEN)
X      if ((Constant_Id = Find_Constant()) != -1)
X        if (Constants[(int)Constant_Id].Constant_Type == OBJECT_CONSTANT)
X          Object = (OBJECT *) Copy((OBJECT *) Constants[(int)Constant_Id].Constant_Data);
X        else
X          Type_Error ();
X      else
X        Undeclared ();
X      EXIT
X    END_CASE
X
X    CASE5 (SPHERE_TOKEN, QUADRIC_TOKEN, UNION_TOKEN,
X           INTERSECTION_TOKEN, DIFFERENCE_TOKEN)
X    CASE3 (TRIANGLE_TOKEN, SMOOTH_TRIANGLE_TOKEN, PLANE_TOKEN)
X        UNGET
X        if (Object == NULL)
X           Object = Get_Object();
X
X        Local_Shape = Parse_Shape(Object);
X        Link((OBJECT *)Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
X                (OBJECT **) &(Object -> Shape));
X        EXIT
X    END_CASE
X
X    OTHERWISE
X        Parse_Error (QUADRIC_TOKEN);
X        EXIT
X    END_CASE
X  END_EXPECT
X
X  EXPECT
X    CASE (BOUNDED_TOKEN)
X       EXPECT
X          CASE (END_BOUNDED_TOKEN)
X             EXIT
X          END_CASE
X
X          OTHERWISE
X             UNGET
X             Local_Shape = Parse_Shape(Object);
X             Link((OBJECT *) Local_Shape,
X                  (OBJECT **) &(Local_Shape -> Next_Object),
X                  (OBJECT **) &(Object -> Bounding_Shapes));
X          END_CASE
X       END_EXPECT
X    END_CASE
X
X    CASE2 (COLOR_TOKEN, COLOUR_TOKEN)
X       Parse_Colour (&(Object -> Object_Colour));
X       if (Object->Object_Colour.Alpha != 0.0)
X          Object->Transparency = TRUE;
X    END_CASE
X
X    CASE (TEXTURE_TOKEN)
X      Object -> Object_Texture = Parse_Texture (Object->Object_Texture);
X      if ((Object->Object_Texture->Colour1.Alpha != 0.0) ||
X          (Object->Object_Texture->Colour2.Alpha != 0.0))
X         Object->Transparency = TRUE;
X      else
X         if (Object->Object_Texture->Colour_Map != NULL)
X            for (i = 0 ; i < Object->Object_Texture->Colour_Map->Number_Of_Entries ; i++)
X               if ((Object->Object_Texture->Colour_Map->Colour_Map_Entries[i].Start_Colour.Alpha != 0.0) ||
X                   (Object->Object_Texture->Colour_Map->Colour_Map_Entries[i].Start_Colour.Alpha != 0.0)) {
X                  Object->Transparency = TRUE;
X                  break;
X                  }
X    END_CASE
X
X    CASE (LIGHT_SOURCE_TOKEN)
X      Object -> Light_Source_Flag = TRUE;
X    END_CASE
X
X    CASE (TRANSLATE_TOKEN)
X       Parse_Vector (&Local_Vector);
X       Translate (Object, &Local_Vector);
X    END_CASE
X
X    CASE (ROTATE_TOKEN)
X       Parse_Vector (&Local_Vector);
X       Rotate (Object, &Local_Vector);
X    END_CASE
X
X    CASE (SCALE_TOKEN)
X       Parse_Vector (&Local_Vector);
X       Scale (Object, &Local_Vector);
X    END_CASE
X
X    CASE (INVERSE_TOKEN)
X       Invert (Object);
X    END_CASE
X
X    CASE (AMBIENT_TOKEN)
X      if (Object -> Object_Texture == Default_Texture)
X         Object -> Object_Texture = Get_Texture();
X
X      (Object -> Object_Texture -> Object_Ambient) = Parse_Float ();
X    END_CASE
X
X    CASE (BRILLIANCE_TOKEN)
X      if (Object -> Object_Texture == Default_Texture)
X         Object -> Object_Texture = Get_Texture();
X
X      (Object -> Object_Texture -> Object_Brilliance) = Parse_Float ();
X    END_CASE
X
X    CASE (ROUGHNESS_TOKEN)
X      if (Object -> Object_Texture == Default_Texture)
X         Object -> Object_Texture = Get_Texture();
X
X      (Object -> Object_Texture -> Object_Roughness) = Parse_Float ();
X      if (Object -> Object_Texture -> Object_Roughness > 1.0)
X         Object -> Object_Texture -> Object_Roughness = 1.0;
X      if (Object -> Object_Texture -> Object_Roughness < 0.001)
X         Object -> Object_Texture -> Object_Roughness = 0.001;
X    END_CASE
X
X    CASE (PHONGSIZE_TOKEN)
X      if (Object -> Object_Texture == Default_Texture)
X         Object -> Object_Texture = Get_Texture();
X
X      (Object -> Object_Texture -> Object_PhongSize) = Parse_Float ();
X      if (Object -> Object_Texture -> Object_PhongSize < 1.0)
X         Object -> Object_Texture -> Object_PhongSize = 1.0;
X      if (Object -> Object_Texture -> Object_PhongSize > 100)
X         Object -> Object_Texture -> Object_PhongSize = 100;
X    END_CASE
X
X    CASE (DIFFUSE_TOKEN)
X      if (Object -> Object_Texture == Default_Texture)
X         Object -> Object_Texture = Get_Texture();
X
X      (Object -> Object_Texture -> Object_Diffuse) = Parse_Float ();
X    END_CASE
X
X    CASE (SPECULAR_TOKEN)
X      if (Object -> Object_Texture == Default_Texture)
X         Object -> Object_Texture = Get_Texture();
X
X      (Object -> Object_Texture -> Object_Specular) = Parse_Float ();
X    END_CASE
X
X    CASE (PHONG_TOKEN)
X      if (Object -> Object_Texture == Default_Texture)
X         Object -> Object_Texture = Get_Texture();
X
X      (Object -> Object_Texture -> Object_Phong) = Parse_Float ();
X    END_CASE
X
X    CASE (IOR_TOKEN)
X      if (Object -> Object_Texture == Default_Texture)
X         Object -> Object_Texture = Get_Texture();
X
X      (Object -> Object_Texture -> Object_Index_Of_Refraction) = Parse_Float ();
X    END_CASE
X
X    CASE (REFRACTION_TOKEN)
X      if (Object -> Object_Texture == Default_Texture)
X         Object -> Object_Texture = Get_Texture();
X
X      (Object -> Object_Texture -> Object_Refraction) = Parse_Float ();
X    END_CASE
X
X    CASE (REFLECTION_TOKEN)
X      if (Object -> Object_Texture == Default_Texture)
X         Object -> Object_Texture = Get_Texture();
X
X      (Object -> Object_Texture -> Object_Reflection) = Parse_Float ();
X    END_CASE
X
X    CASE (END_OBJECT_TOKEN)
X      EXIT
X    END_CASE
X
X    OTHERWISE
X      Parse_Error (END_OBJECT_TOKEN);
X    END_CASE
X
X  END_EXPECT
X
X  return (Object);
X  }
X
XOBJECT *Parse_Composite ()
X  {
X  COMPOSITE *Local_Composite;
X  OBJECT *Local_Object;
X  SHAPE *Local_Shape;
X  CONSTANT Constant_Id;
X  VECTOR Local_Vector;
X
X  Local_Composite = NULL;
X
X  EXPECT
X    CASE (IDENTIFIER_TOKEN)
X      if ((Constant_Id = Find_Constant()) != -1)
X        if (Constants[(int)Constant_Id].Constant_Type == COMPOSITE_CONSTANT)
X          Local_Composite = (COMPOSITE *)Copy((OBJECT *) Constants[(int)Constant_Id].Constant_Data);
X        else
X          Type_Error ();
X      else
X        Undeclared ();
X    END_CASE
X
X    CASE (COMPOSITE_TOKEN)
X      if (Local_Composite == NULL)
X           Local_Composite = Get_Composite_Object();
X
X      Local_Object = Parse_Composite();
X      Link((OBJECT *) Local_Object,(OBJECT **) &(Local_Object -> Next_Object),
X              (OBJECT **) &(Local_Composite -> Objects));
X    END_CASE
X
X    CASE (OBJECT_TOKEN)
X      if (Local_Composite == NULL)
X           Local_Composite = Get_Composite_Object();
X
X      Local_Object = Parse_Object();
X      Link(Local_Object, &(Local_Object -> Next_Object),
X               &(Local_Composite -> Objects));
X
X      if (Local_Object -> Light_Source_Flag)
X         Link(Local_Object, &(Local_Object -> Next_Light_Source),
X               &(Parsing_Frame_Ptr -> Light_Sources));
X    END_CASE
X
X    CASE (END_COMPOSITE_TOKEN)
X      UNGET
X      if (Local_Composite == NULL)
X        Local_Composite = Get_Composite_Object();
X
X      EXIT
X    END_CASE
X
X    OTHERWISE
X       UNGET
X       EXIT
X    END_CASE
X  END_EXPECT
X
X  EXPECT
X    CASE (END_COMPOSITE_TOKEN)
X       EXIT
X    END_CASE
X
X    CASE (BOUNDED_TOKEN)
X       EXPECT
X          CASE (END_BOUNDED_TOKEN)
X             EXIT
X          END_CASE
X
X          OTHERWISE
X             UNGET
X             Local_Shape = Parse_Shape((OBJECT *) Local_Composite);
X             Link((OBJECT *) Local_Shape,
X                  (OBJECT **) &(Local_Shape -> Next_Object),
X                  (OBJECT **) &(Local_Composite -> Bounding_Shapes));
X          END_CASE
X       END_EXPECT
X    END_CASE
X
X    CASE (TRANSLATE_TOKEN)
X       Parse_Vector (&Local_Vector);
X       Translate ((OBJECT *) Local_Composite, &Local_Vector);
X    END_CASE
X
X    CASE (ROTATE_TOKEN)
X       Parse_Vector (&Local_Vector);
X       Rotate ((OBJECT *) Local_Composite, &Local_Vector);
X    END_CASE
X
X    CASE (SCALE_TOKEN)
X       Parse_Vector (&Local_Vector);
X       Scale ((OBJECT *) Local_Composite, &Local_Vector);
X    END_CASE
X
X     CASE (INVERSE_TOKEN)
X        Invert ((OBJECT *) Local_Composite);
X     END_CASE
X
X    OTHERWISE
X       Parse_Error (END_COMPOSITE_TOKEN);
X    END_CASE
X  END_EXPECT
X
X  return ((OBJECT *) Local_Composite);
X  }
X
Xvoid Parse_Fog ()
X   {
X   EXPECT
X      CASE (COLOUR_TOKEN)
X         Parse_Colour (&Parsing_Frame_Ptr->Fog_Colour);
X      END_CASE
X
X      CASE (FLOAT_TOKEN)
X         Parsing_Frame_Ptr->Fog_Distance = Token.Token_Float;
X      END_CASE
X
X      CASE (END_FOG_TOKEN)
X         EXIT
X      END_CASE
X
X      OTHERWISE
X         Parse_Error (END_FOG_TOKEN);
X      END_CASE
X   END_EXPECT
X   }
X
Xvoid Parse_Frame ()
X  {
X  OBJECT *Local_Object;
X
X  EXPECT
X    CASE (FOG_TOKEN)
X       Parse_Fog();
X    END_CASE
X
X    CASE (OBJECT_TOKEN)
X      Local_Object = Parse_Object();
X      Link(Local_Object, &(Local_Object -> Next_Object),
X             &(Parsing_Frame_Ptr -> Objects));
X
X      if (Local_Object -> Light_Source_Flag)
X         Link(Local_Object, &(Local_Object -> Next_Light_Source),
X               &(Parsing_Frame_Ptr -> Light_Sources));
X    END_CASE
X
X    CASE (COMPOSITE_TOKEN)
X      Local_Object = Parse_Composite();
X      Link(Local_Object, &(Local_Object -> Next_Object),
X            &(Parsing_Frame_Ptr -> Objects));
X    END_CASE
X
X    CASE (VIEW_POINT_TOKEN)
X      Parse_Viewpoint(&(Parsing_Frame_Ptr -> View_Point));
X    END_CASE
X
X    CASE (DECLARE_TOKEN)
X      Parse_Declare ();
X    END_CASE
X
X    CASE (END_OF_FILE_TOKEN)
X      EXIT
X    END_CASE
X
X    OTHERWISE
X      Parse_Error (OBJECT_TOKEN);
X    END_CASE
X  END_EXPECT
X  }
X
Xvoid Parse_Viewpoint (Given_Vp)
X  VIEWPOINT *Given_Vp;
X  {
X  CONSTANT Constant_Id;
X  VECTOR Local_Vector, Temp_Vector;
X  DBL Direction_Length, Up_Length, Right_Length, Handedness;
X
X  Init_Viewpoint (Given_Vp);
X
X  EXPECT
X    CASE (IDENTIFIER_TOKEN)
X      if ((Constant_Id = Find_Constant()) != -1)
X        if (Constants[(int)Constant_Id].Constant_Type == VIEW_POINT_CONSTANT)
X          *Given_Vp =
X             *((VIEWPOINT*) Constants[(int)Constant_Id].Constant_Data);
X        else
X          Type_Error ();
X      else
X        Undeclared ();
X    END_CASE
X
X    CASE (LOCATION_TOKEN)
X      Parse_Vector(&(Given_Vp -> Location));
X    END_CASE
X
X    CASE (DIRECTION_TOKEN)
X      Parse_Vector(&(Given_Vp -> Direction));
X    END_CASE
X
X    CASE (UP_TOKEN)
X      Parse_Vector(&(Given_Vp -> Up));
X    END_CASE
X
X    CASE (RIGHT_TOKEN)
X      Parse_Vector(&(Given_Vp -> Right));
X    END_CASE
X
X    CASE (SKY_TOKEN)
X      Parse_Vector(&(Given_Vp -> Sky));
X    END_CASE
X
X    CASE (LOOK_AT_TOKEN)
X       VLength (Direction_Length, Given_Vp->Direction);
X       VLength (Up_Length, Given_Vp->Up);
X       VLength (Right_Length, Given_Vp->Right);
X       VCross (Temp_Vector, Given_Vp->Direction, Given_Vp->Up);
X       VDot (Handedness, Temp_Vector, Given_Vp->Right);
X       Parse_Vector(&Given_Vp->Direction);
X
X       VSub (Given_Vp->Direction, Given_Vp->Direction, Given_Vp->Location);
X       VNormalize (Given_Vp->Direction, Given_Vp->Direction);
X       VCross(Given_Vp->Right, Given_Vp->Direction, Given_Vp->Sky);
X       VNormalize (Given_Vp->Right, Given_Vp->Right);
X       VCross (Given_Vp->Up, Given_Vp->Right, Given_Vp->Direction);
X       VScale (Given_Vp->Direction, Given_Vp->Direction, Direction_Length);
X       if (Handedness >= 0.0) {
X          VScale (Given_Vp->Right, Given_Vp->Right, Right_Length);
X          }
X       else {
X          VScale (Given_Vp->Right, Given_Vp->Right, -Right_Length);
X          }
X
X       VScale (Given_Vp->Up, Given_Vp->Up, Up_Length);
X    END_CASE
X
X    CASE (TRANSLATE_TOKEN)
X       Parse_Vector (&Local_Vector);
X       Translate ((OBJECT *) Given_Vp, &Local_Vector);
X    END_CASE
X
X    CASE (ROTATE_TOKEN)
X       Parse_Vector (&Local_Vector);
X       Rotate ((OBJECT *) Given_Vp, &Local_Vector);
X    END_CASE
X
X    CASE (SCALE_TOKEN)
X       Parse_Vector (&Local_Vector);
X       Scale ((OBJECT *) Given_Vp, &Local_Vector);
X    END_CASE
X
X    CASE (END_VIEW_POINT_TOKEN)
X      EXIT
X    END_CASE
X
X    OTHERWISE
X      Parse_Error (END_VIEW_POINT_TOKEN);
X    END_CASE
X  END_EXPECT
X  }
X
Xvoid Parse_Declare ()
X  {
X  CONSTANT Constant_Id;
X
X  struct Constant_Struct *Constant_Ptr;
X
X  GET (IDENTIFIER_TOKEN);
X  if ((Constant_Id = Find_Constant()) == -1)
X    if (++Number_Of_Constants >= MAX_CONSTANTS)
X      Error ("Too many constants");
X    else
X      Constant_Id = Number_Of_Constants;
X
X  Constant_Ptr = &(Constants[(int)Constant_Id]);
X  GET (EQUALS_TOKEN);
X
X  EXPECT
X    CASE (OBJECT_TOKEN)
X      Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
X      Constant_Ptr -> Constant_Data = (char *) Parse_Object();
X      Constant_Ptr -> Constant_Type = OBJECT_CONSTANT;
X      EXIT
X    END_CASE
X
X    CASE (SPHERE_TOKEN)
X      Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
X      Constant_Ptr -> Constant_Data = (char *) Parse_Sphere ();
X      Constant_Ptr -> Constant_Type = SPHERE_CONSTANT;
X      EXIT
X    END_CASE
X
X    CASE (PLANE_TOKEN)
X      Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
X      Constant_Ptr -> Constant_Data = (char *) Parse_Plane ();
X      Constant_Ptr -> Constant_Type = PLANE_CONSTANT;
X      EXIT
X    END_CASE
X
X    CASE (TRIANGLE_TOKEN)
X      Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
X      Constant_Ptr -> Constant_Data = (char *) Parse_Triangle ();
X      Constant_Ptr -> Constant_Type = TRIANGLE_CONSTANT;
X      EXIT
X    END_CASE
X
X    CASE (SMOOTH_TRIANGLE_TOKEN)
X      Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
X      Constant_Ptr -> Constant_Data = (char *) Parse_Smooth_Triangle ();
X      Constant_Ptr -> Constant_Type = SMOOTH_TRIANGLE_CONSTANT;
X      EXIT
X    END_CASE
X
X    CASE (QUADRIC_TOKEN)
X      Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
X      Constant_Ptr -> Constant_Data = (char *) Parse_Quadric ();
X      Constant_Ptr -> Constant_Type = QUADRIC_CONSTANT;
X      EXIT
X    END_CASE
X
X    CASE (INTERSECTION_TOKEN)
X      Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
X      Constant_Ptr -> Constant_Data = (char *) Parse_CSG(CSG_INTERSECTION_TYPE, NULL);
X      Constant_Ptr -> Constant_Type = CSG_INTERSECTION_CONSTANT;
X      EXIT
X    END_CASE
X
X    CASE (UNION_TOKEN)
X      Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
X      Constant_Ptr -> Constant_Data = (char *) Parse_CSG(CSG_UNION_TYPE, NULL);
X      Constant_Ptr -> Constant_Type = CSG_UNION_CONSTANT;
X      EXIT
X    END_CASE
X
X    CASE (DIFFERENCE_TOKEN)
X      Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
X      Constant_Ptr -> Constant_Data = (char *) Parse_CSG(CSG_DIFFERENCE_TYPE, NULL);
X      Constant_Ptr -> Constant_Type = CSG_DIFFERENCE_CONSTANT;
X      EXIT
X    END_CASE
X
X    CASE (COMPOSITE_TOKEN)
X      Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
X      Constant_Ptr -> Constant_Data = (char *) Parse_Composite();
X      Constant_Ptr -> Constant_Type = COMPOSITE_CONSTANT;
X      EXIT
X    END_CASE
X
X    CASE (TEXTURE_TOKEN)
X      Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
X      Constant_Ptr -> Constant_Data = (char *) Parse_Texture(Default_Texture);
X      Constant_Ptr -> Constant_Type = TEXTURE_CONSTANT;
X      EXIT
X    END_CASE
X
X    CASE (VIEW_POINT_TOKEN)
X      Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
X      Constant_Ptr -> Constant_Data = (char *) Get_Viewpoint();
X      Constant_Ptr -> Constant_Type = VIEW_POINT_CONSTANT;
X      Parse_Viewpoint((VIEWPOINT *) Constant_Ptr -> Constant_Data);
X      EXIT
X    END_CASE
X
X    CASE2 (COLOR_TOKEN, COLOUR_TOKEN)
X      Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
X      Constant_Ptr -> Constant_Data = (char *) Get_Colour();
X      Constant_Ptr -> Constant_Type = COLOUR_CONSTANT;
X      Parse_Colour ((COLOUR *) Constant_Ptr -> Constant_Data);
X      EXIT
X    END_CASE
X
X    CASE (LEFT_ANGLE_TOKEN)
X      UNGET
X      Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
X      Constant_Ptr -> Constant_Data = (char *) Get_Vector();
X      Constant_Ptr -> Constant_Type = VECTOR_CONSTANT;
X      Parse_Vector((VECTOR *) Constant_Ptr -> Constant_Data);
X      EXIT
X    END_CASE
X
X    CASE3 (DASH_TOKEN, PLUS_TOKEN, FLOAT_TOKEN)
X      UNGET
X      Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
X      Constant_Ptr -> Constant_Data = (char *) Get_Float();
X      Constant_Ptr -> Constant_Type = FLOAT_CONSTANT;
X      *(Constant_Ptr -> Constant_Data) = Parse_Float();
X      EXIT
X    END_CASE
X
X    OTHERWISE
X      Parse_Error (OBJECT_TOKEN);
X    END_CASE
X  END_EXPECT
X  }
X
Xvoid Init_Viewpoint (vp)
X  VIEWPOINT *vp;
X  {
X  vp -> Methods = (void *) &Viewpoint_Methods;
X  vp -> Type = VIEWPOINT_TYPE;
X  Make_Vector (&vp->Location, 0.0, 0.0, 0.0);
X  Make_Vector (&vp->Direction, 0.0, 0.0, 1.0);
X  Make_Vector (&vp->Up, 0.0, 1.0, 0.0);
X  Make_Vector (&vp->Right, 1.0, 0.0, 0.0);
X  Make_Vector (&vp->Sky, 0.0, 1.0, 0.0);
X  }
X
Xvoid Link (New_Object, Field, Old_Object_List)
X  OBJECT *New_Object, **Field, **Old_Object_List;
X  {
X  *Field = *Old_Object_List;
X  *Old_Object_List = New_Object;
X  }
X
XCONSTANT Find_Constant()
X  {
X  register int i;
X
X  for (i = 1 ; i <= Number_Of_Constants ; i++)
X    if (Constants [i].Identifier_Number == Token.Identifier_Number)
X      return (i);
X
X  return (-1);
X  }
X
X
Xchar *Get_Token_String (Token_Id)
X  TOKEN Token_Id;
X  {
X  register int i;
X
X  for (i = 0 ; i < LAST_TOKEN ; i++)
X     if (Reserved_Words[i].Token_Number == Token_Id)
X        return (Reserved_Words[i].Token_Name);
X  return ("");
X  }
X
Xvoid Parse_Error (Token_Id)
X  TOKEN Token_Id;
X  {
X  char *expected, *found;
X
X  fprintf (stderr, "Error in file %s line %d\n", Current_File_Name,
X                                                 Token.Token_Line_No);
X  expected = Get_Token_String (Token_Id);
X  found = Get_Token_String (Token.Token_Id);
X  fprintf (stderr, "%s expected but %s found instead\n", expected, found);
X  exit(0);
X  }
X
Xvoid Type_Error ()
X  {
X  fprintf (stderr, "Error in file %s line %d\n", Current_File_Name,
X                                                 Token.Token_Line_No);
X  fprintf (stderr, "Identifier %s is the wrong type\n",
X            &Token.Token_String[0]);
X  exit (0);
X  }
X
Xvoid Undeclared ()
X  {
X  fprintf (stderr, "Error in file %s line %d\n", Current_File_Name,
X                                                 Token.Token_Line_No);
X  fprintf (stderr, "Undeclared identifier %s\n", &Token.Token_String[0]);
X  exit (0);
X  }
X
Xvoid Error (str)
X  char *str;
X  {
X  fprintf (stderr, "Error in file %s line %d\n", Current_File_Name,
X                                                 Token.Token_Line_No);
X  fputs (str, stderr);
X  exit (0);
X  }
X
END_OF_FILE
if test 63678 -ne `wc -c <'src/parse.c'`; then
    echo shar: \"'src/parse.c'\" unpacked with wrong size!
fi
# end of 'src/parse.c'
fi
echo shar: End of archive 9 \(of 10\).
cp /dev/null ark9isdone
MISSING=""
for I in 1 2 3 4 5 6 7 8 9 10 ; do
    if test ! -f ark${I}isdone ; then
    MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 10 archives.
    rm -f ark[1-9]isdone ark[1-9][0-9]isdone
else
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
fi
##  End of shell archive.
exit 0
--
Mail submissions (sources or binaries) to <[e-mail]>.
Mail comments to the moderator at <[e-mail]>.
Post requests for sources, and general discussion to comp.sys.amiga.